MMA68xx_Diag.c

#include "derivative.h" /* Contains type declarations */
#include "compile_options.h"
#include "MMA68xx.h"
#include "HAL.h"
#include "MailScheduler.h"
#include "DSPI.h"
#include "Utils.h"
#include <limits.h> /* To set limits */
#include "MMA68xx_Diag.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint16_t cau16MMA6800TestSettingsRaw[] =
{
  /* Test1 & Test3, Raw data                           */
  (MMA6800_DEVCFG | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x95u),     /*Raw data*/
  (MMA6800_DEVCFG_X | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x09u),   /*Self test X non activated*/
  (MMA6800_DEVCFG_Y | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x0Au)};  /*Self test Y non activated*/

const uint16_t cau16MMA6800TestSettingsRawSelfX[] =
{
  /* Test2, Raw data, Self test X                      */
  (MMA6800_DEVCFG | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x95u),     /*Raw data*/
  (MMA6800_DEVCFG_X | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x89u),   /*Self test X activated*/
  (MMA6800_DEVCFG_Y | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x0Au)};  /*Self test Y non activated*/
  
const uint16_t cau16MMA6800TestSettingsRawSelfY[] =
{
  /* Test2, Raw data, Self test Y                      */
  (MMA6800_DEVCFG | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x95u),     /*Raw data*/
  (MMA6800_DEVCFG_X | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x09u),   /*Self test X non activated*/
  (MMA6800_DEVCFG_Y | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x8Au)};  /*Self test Y activated*/

const uint16_t cau16MMA6800TestSettingsOC[] =
{
  /* Test1 & Test3, Raw data                           */
  (MMA6800_DEVCFG | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x15u),     /*Offset canceled data*/
  (MMA6800_DEVCFG_X | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x09u),   /*Self test X non activated*/
  (MMA6800_DEVCFG_Y | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x0Au)};  /*Self test Y non activated*/

const uint16_t cau16MMA6800TestSettingsOCSelfX[] =
{
  /* Test2, Raw data, Self test X                      */
  (MMA6800_DEVCFG | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x15u),     /*Offset canceled data*/
  (MMA6800_DEVCFG_X | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x89u),   /*Self test X activated*/
  (MMA6800_DEVCFG_Y | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x0Au)};  /*Self test Y non activated*/

const uint16_t cau16MMA6800TestSettingsOCSelfY[] =
{
  /* Test2, Raw data, Self test Y                      */
  (MMA6800_DEVCFG | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x15u),     /*Offset canceled data*/
  (MMA6800_DEVCFG_X | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x09u),   /*Self test X non activated*/
  (MMA6800_DEVCFG_Y | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x8Au)};  /*Self test Y activated*/

const uint32_t cau32MMA6800ErrorCodeX[] =
{
  /* Error codes for X axis */
     STATUS_CA_RAW_X_FAILED, STATUS_CA_RAW_SELF_X_FAILED, STATUS_CA_RAW_HYST_X_FAILED,
     STATUS_CA_OC_X_FAILED, STATUS_CA_OC_SELF_X_FAILED, STATUS_CA_OC_HYST_X_FAILED};

const uint32_t cau32MMA6800ErrorCodeY[] =
{
  /* Error codes for Y axis */
     STATUS_CA_RAW_Y_FAILED, STATUS_CA_RAW_SELF_Y_FAILED, STATUS_CA_RAW_HYST_Y_FAILED,
     STATUS_CA_OC_Y_FAILED, STATUS_CA_OC_SELF_Y_FAILED, STATUS_CA_OC_HYST_Y_FAILED};

const uint8_t cu8SizeofTestSettings = N_ELEMENTS(cau16MMA6800TestSettingsRaw);
const uint8_t cu8SizeofTestAmount = N_ELEMENTS(cau32MMA6800ErrorCodeX);

/*
 ******************************************************************************
 * u32fnMMA6800PreSelfTest
 ******************************************************************************
 */
uint32_t u32fnMMA6800PreSelfTest(uint32_t* pu32Destination,
                                 const uint16_t* pu16DataToSend,
                                 const uint8_t u8Size,
                                 const uint8_t cu8AccelMode,
                                 const uint8_t cu8Axis,
                                 const uint16_t cu16LowLimit,
                                 const uint16_t cu16HighLimit,
                                 const uint32_t cu32StatusErrCode,
                                 const uint8_t cu8Accel)
{
  /* Declare local variables */
  uint32_t u32Status;
  uint32_t u32LowLimit;
  uint32_t u32HighLimit;  

  /* Init local variables */
  u32Status = CLEAR;

  /*Limit definitions*/
  u32LowLimit = CA_TEST_SAMPLES_AMOUNT * cu16LowLimit;
  u32HighLimit = CA_TEST_SAMPLES_AMOUNT * cu16HighLimit;    
        
  /* Reading of several accelerations along cu8Axis axis*/
  u32Status |= u32fnMMA6800ConfigTest((uint32_t*) pu32Destination,
                                      (uint16_t*) pu16DataToSend,
                                      (uint8_t) u8Size,
                                      (uint8_t) cu8AccelMode,
                                      (uint8_t) cu8Axis,
                                      (uint8_t) cu8Accel);
    
  DELAY_MSEC(1u);

  /*Diagnostic of test*/
  /*Spec item 59a and 67b, for 12-bits unsigned and 105.5g sensitivity,
    according to Raw or OC data*/
    if((u32LowLimit < *pu32Destination) && (u32HighLimit > *pu32Destination))
    {
      /* Nothing to do */
    }
    else
    {
      u32Status |= cu32StatusErrCode;
    }
    return(u32Status);
}
/*
 ******************************************************************************
 * u32fnMMA6800PowerOnSelfTest
 ******************************************************************************
 */
uint32_t u32fnMMA6800PowerOnSelfTest(uint32_t* pu32Destination,
                                     const uint16_t* pu16DataToSend,
                                     const uint16_t* pu16DataToSendCross,
                                     const uint8_t u8Size,                                     
                                     const uint8_t cu8AccelMode,
                                     const uint8_t cu8Axis,
                                     const uint32_t cu32StatusErrCode,
                                     const uint8_t cu8Accel)
{
  /* Declare local variables */
  uint32_t u32Status;
  uint32_t au32FilteredSum[4];
  uint32_t au32CrossAxis;
  uint32_t au32SelfTestDeflection;
  uint32_t au32CrossAxisSelfTest;
  uint32_t u32LowLimit;
  uint32_t u32HighLimit;  
  uint32_t u32CompLimit;
  uint32_t u32CrossLimit;

  /* Init local variables */
  u32Status = CLEAR;
   
  /*Limit definitions*/
    u32LowLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_SELF_LIMIT_LO;
    u32HighLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_SELF_LIMIT_HI;
    u32CompLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_SELF_RAW_VS_OC_LIMIT;
    u32CrossLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_SELF_CROSS_AXIS_LIMIT;
   
    /* Reading of several accelerations along cu8Axis axis with cu8Axis self test activated */
    u32Status = u32fnMMA6800ConfigTest((uint32_t*) pu32Destination,
                                       (uint16_t*) pu16DataToSend,
                                       (uint8_t) u8Size,
                                       (uint8_t) cu8AccelMode,
                                       (uint8_t) cu8Axis,
                                       (uint8_t) cu8Accel);

    DELAY_MSEC(1u);
                
    au32FilteredSum[1] = *pu32Destination;
    au32FilteredSum[0] = *(--pu32Destination);
    
  /****************************************** MAIN AXIS **************************************/    
  /*Test1*/
  /*Self test deflection value*/
  /*Spec item 90, for 105.5g sensitivity and 25°C*/
    au32SelfTestDeflection = au32FilteredSum[1] - au32FilteredSum[0];    
    if((u32LowLimit < au32SelfTestDeflection) && (u32HighLimit > au32SelfTestDeflection))
    {
      /* Nothing to do */
    }
    else
    {
      u32Status |= cu32StatusErrCode;
    }
  /*Test2*/
  /*Comparison of Self test deflection values for Raw and OC data */
  /* (Test valid for OC conf only) */
    if(OC_ACCEL_MODE == cu8AccelMode)
    {
      /* Go in Power On and Pre Self tests for Raw data (jump Post Self test for Raw data)*/
      *(--pu32Destination);
      *(--pu32Destination);      
      au32FilteredSum[3] = *pu32Destination;
      au32FilteredSum[2] = *(--pu32Destination);
      au32SelfTestDeflection = u32fnDiffAbsoluteValue((au32FilteredSum[1] - au32FilteredSum[0]),
                                                      (au32FilteredSum[3] - au32FilteredSum[2]));
      /*+-5 LSB given by Russ*/  
      if(au32SelfTestDeflection < u32CompLimit)
      {
        /* Nothing to do */
      }
      else
      {
        u32Status |= cu32StatusErrCode;
      }
    }        
  /*************************************** CROSS AXIS ****************************************/       
  /* Reading of several accelerations along cu8Axis axis cross axis self test activated */
    u32Status |= u32fnMMA6800ConfigTest((uint32_t*) &au32CrossAxis,
                                        (uint16_t*) pu16DataToSendCross,
                                        (uint8_t) u8Size,
                                        (uint8_t) cu8AccelMode,
                                        (uint8_t) cu8Axis,
                                        (uint8_t) cu8Accel);

       DELAY_MSEC(1u);
                   
    au32FilteredSum[1] = au32CrossAxis;
       
    /*Test3*/
    /*Self test cross axis, spec item 96 and 97*/
    au32CrossAxisSelfTest = u32fnDiffAbsoluteValue(au32FilteredSum[1], au32FilteredSum[0]);       
    if(u32CrossLimit > au32CrossAxisSelfTest)
    {
      /* Nothing to do */
    }
    else
    {
      u32Status |= cu32StatusErrCode;
    }

    return(u32Status);
}
/*
 ******************************************************************************
 * u32fnMMA6800PostSelfTest
 ******************************************************************************
 */
uint32_t u32fnMMA6800PostSelfTest(uint32_t* pu32Destination,
                                  const uint16_t* pu16DataToSend,
                                  const uint8_t u8Size,                                  
                                  const uint8_t cu8AccelMode,
                                  const uint8_t cu8Axis,
                                  const uint32_t cu32StatusErrCode,
                                  const uint8_t cu8Accel)
{
  /* Declare local variables */
  uint32_t u32Status;
  uint32_t au32FilteredSum[2];
  uint32_t au32PostSelfTest;
  uint32_t u32LowLimit;
  uint32_t u32HighLimit;  
  uint32_t u32HystLimit;

  /* Init local variables */
  u32Status = CLEAR;
  
  /*Limit definitions*/    
    u32LowLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_OC_LIMIT_LO;
    u32HighLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_OC_LIMIT_HI;    
    u32HystLimit = CA_TEST_SAMPLES_AMOUNT * CA_TEST_RAW_LIMIT_HYST;
        
    /* Reading of several accelerations along cu8Axis axis*/
    u32Status |= u32fnMMA6800ConfigTest((uint32_t*) pu32Destination,
                                        (uint16_t*) pu16DataToSend,
                                        (uint8_t) u8Size,
                                        (uint8_t) cu8AccelMode,
                                        (uint8_t) cu8Axis,
                                        (uint8_t) cu8Accel);
    
    DELAY_MSEC(1u);
    
    au32FilteredSum[1] = *(pu32Destination--);
    au32FilteredSum[0] = *(--pu32Destination);   
    
    /*Diagnostic of test according to Raw or OC data*/
    if(RAW_ACCEL_MODE == cu8AccelMode)
    {
      au32PostSelfTest = u32fnDiffAbsoluteValue(au32FilteredSum[0], au32FilteredSum[1]);
      if(u32HystLimit > au32PostSelfTest)
      {
        /* Nothing to do */
      }
      else
      {
        u32Status |= cu32StatusErrCode;
      }
    }
    else if (OC_ACCEL_MODE == cu8AccelMode)
    {
      if((u32LowLimit < au32FilteredSum[1]) && (u32HighLimit > au32FilteredSum[1]))
      {
        /* Nothing to do */
      }
      else
      {
        u32Status |= cu32StatusErrCode;
      }
    }
    return(u32Status);
}
/*
 ******************************************************************************
 * u32fnMMA6800ConfigTest
 ******************************************************************************
 */
uint32_t u32fnMMA6800ConfigTest(uint32_t* pu32Destination,
                                const uint16_t* pu16DataToSend,
                                const uint8_t u8Size,
                                const uint8_t u8AccelMode,
                                const uint8_t u8Axis,
                                const uint8_t cu8Accel)
{
  /* Declare local variables */
  uint32_t u32Status;
  uint8_t u8Status;

  /* Init local variables */
  u32Status = CLEAR;
  u8Status = CLEAR;  
   
  /*CA configuration*/    
    u8Status = ((*u8pfnMMA6800BatchOp[MMA6800_TRANSFER_MODE_IS_SCHEDULED])
                (MAIN_ACCELERO_SPI_CONFIG,( uint16_t*)pu16DataToSend,
                (uint16_t*)gau8MMA6800GlobalResult,
                (uint8_t)u8Size));
    
    DELAY_MSEC(5u);
    
  /*Reading of several acceleration data*/    
    u32Status = u32fnMMA6800ReadAccelSum((uint8_t) u8Axis, (uint8_t) u8AccelMode, 
                                         (uint32_t*) pu32Destination, cu8Accel);    
    
    DELAY_MSEC(1u);
    
    return(u32Status);
}
/*
 ******************************************************************************
 * u32fnMMA6800ReadAccelSum
 ******************************************************************************
 */
uint32_t u32fnMMA6800ReadAccelSum(const uint8_t u8Axis,
                                  const uint8_t u8AccelMode,
                                  uint32_t* pu32Destination,
                                  const uint8_t cu8Accel)
{
  /* Declare local variables */
  uint32_t u32Status;
  uint8_t  u8Status;  
  uint16_t u16Counter;
  uint32_t au32TempResults[CA_TEST_SAMPLES_AMOUNT]= {CLEAR};
  uint16_t au16RawResult[2u];
  uint16_t au16Filtered;
  uint32_t u32Time0;

  
  /* Init local variables */
  u32Status = CLEAR;
  u8Status = CLEAR;
  u16Counter = CLEAR;
  *pu32Destination = CLEAR;
  
  for(u16Counter = CLEAR; u16Counter < CA_TEST_SAMPLES_AMOUNT; u16Counter++)
  {  
    u8Status = u8fnMMA6800ReadAccel(MAIN_ACCELERO_SPI_CONFIG, 
                                    MMA6800_TRANSFER_MODE_IS_SCHEDULED, 
                                    u8Axis,
                                    u8AccelMode,
                                    (uint16_t*)&au32TempResults[u16Counter],
                                    cu8Accel);

    SCHED_WHAT_IS_THE_TIME(u32Time0);
    /* Wait for signal to be sent to the SBC */
    while(3u > u32fnSchedHasTimeElapsed(u32Time0))
    {
      /* Wait here */
    };
    
    if(CLEAR < u8Status)
    {
      u32Status |= STATUS_CA_FAILED;
    }
    else
    {
      /* Nothing to do */
    }    
  } 
  
  if (CLEAR == u32Status)
  {
    for(u16Counter = CLEAR; u16Counter < CA_TEST_SAMPLES_AMOUNT; u16Counter++)
    {    
      u32Status |= u8fnMMA6800ExtractAccelResponse((uint16_t*)&au32TempResults[u16Counter],
                                                   (uint16_t*)au16RawResult,
                                                   RAW_MMA_ACCEL_ARRAY_SIZE - 1u,
                                                   cu8Accel);
      au16Filtered = au16RawResult[1u];
      *pu32Destination += au16Filtered;
    }
  }
  else
  {
    /* Nothing to do */
  }  
  return(u32Status);
}

/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */